// ==UserScript==
// @name         东方嘉富任务提醒监控
// @namespace    http://tampermonkey.net/
// @version      1.0
// @description  监控东方嘉富共享工作池和个人工作池任务
// @author       AI Assistant
// @match        https://zhprod.sinosoftfrino.info/easyrecordZH/*
// @grant        GM_notification
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_xmlhttpRequest
// @updateURL    https://gitee.com/i-recruit-handsome/i-attract-good-fortune/raw/master/sl-dfjfjk.user.js
// @downloadURL  https://gitee.com/i-recruit-handsome/i-attract-good-fortune/raw/master/sl-dfjfjk.user.js
// ==/UserScript==

(function() {
    'use strict';

    // ==================== 配置项 ====================
    const CONFIG = {
        CHECK_INTERVAL: 5 * 60 * 1000, // 检查间隔：5分钟
        NOTIFICATION_COOLDOWN: 3 * 60 * 1000, // 通知冷却期：3分钟
        NOTIFICATION_DISPLAY_TIME: 60 * 1000 // 通知显示时间：1分钟
    };

    // 全局变量
    let monitorTimer = null;
    let lastNotificationTime = 0;
    let isMonitoring = false;
    // 新增：查询管理界面工具栏观察者，确保按钮持久存在
    let qmObserver = null;
    // 新增：查询管理界面独立的通知冷却时间戳，避免与其他页面互相影响
    let lastQueryNotificationTime = 0;

    // 获取共享工作池任务数
    function getSharedPoolTaskCount() {
        try {
            // 检查第一个表格是否有数据
            const firstTableBodies = document.querySelectorAll('.layui-table-body .layui-table tbody');
            if (firstTableBodies.length > 0) {
                const firstTableBody = firstTableBodies[0];
                // 检查是否显示"无数据"
                const noDataDiv = firstTableBody.parentElement.querySelector('.layui-none');
                if (noDataDiv && noDataDiv.textContent.includes('无数据')) {
                    return 0;
                }
                // 返回表格行数
                return firstTableBody.children.length;
            }
            return 0;
        } catch (error) {
            return 0;
        }
    }

    // 获取个人工作池任务数
    function getPersonalPoolTaskCount() {
        try {
            // 检查第二个表格是否有数据
            const tableBodies = document.querySelectorAll('.layui-table-body .layui-table tbody');
            if (tableBodies.length > 1) {
                const secondTableBody = tableBodies[1];
                // 检查是否显示"无数据"
                const noDataDiv = secondTableBody.parentElement.querySelector('.layui-none');
                if (noDataDiv && noDataDiv.textContent.includes('无数据')) {
                    return 0;
                }
                // 返回表格行数
                return secondTableBody.children.length;
            }
            return 0;
        } catch (error) {
            return 0;
        }
    }

    // 发送通知
    function sendNotifications(sharedPoolCount, personalPoolCount) {
        const now = new Date();
        const timeStr = now.toLocaleString('zh-CN');
        let message = '';
        
        // 根据任务情况构建通知内容
        if (sharedPoolCount > 0 && personalPoolCount > 0) {
            message = `公共池待处理任务${sharedPoolCount}单，请及时处理。\n个人池待处理任务${personalPoolCount}单，请及时处理。\n时间：${timeStr}`;
        } else if (sharedPoolCount > 0) {
            message = `公共池待处理任务${sharedPoolCount}单，请及时处理。\n时间：${timeStr}`;
        } else if (personalPoolCount > 0) {
            message = `个人池待处理任务${personalPoolCount}单，请及时处理。\n时间：${timeStr}`;
        }
        
        if (message) {
            // 发送系统通知
            showLocalNotification(message, '东方嘉富任务提醒!');
        }
    }

    // 显示本地通知
    // 显示本地通知
    function showLocalNotification(message, title = '东方嘉富任务提醒!') {
        if (Notification.permission === 'granted') {
            // 优化通知配置，减少不必要的网络请求和操作
            const notification = new Notification(title, {
                body: message,
                tag: 'quality-check-monitor', // 使用tag确保同类通知不重复
                requireInteraction: true, // 防止浏览器自动关闭
                silent: false,
                renotify: true // 允许重复通知
            });

            // 点击通知时切换回当前页面
            notification.onclick = function() {
                window.focus();
                notification.close();
            };

            // 自动关闭通知
            setTimeout(() => {
                if (notification) {
                    notification.close();
                }
            }, CONFIG.NOTIFICATION_DISPLAY_TIME);

        } else {
            // 如果没有浏览器通知权限，优先尝试 Tampermonkey 的 GM_notification
            try {
                if (typeof GM_notification === 'function') {
                    GM_notification({
                        title: title,
                        text: message,
                        timeout: CONFIG.NOTIFICATION_DISPLAY_TIME
                    });
                } else {
                    // 仍然兜底为 alert
                    alert(`${title}\n${message}`);
                }
            } catch (e) {
                // 兜底为 alert，确保一定能看到提醒
                alert(`${title}\n${message}`);
            }
        }
    }

    // 检查并发送通知
    function checkAndNotify() {
        const now = Date.now();
        const timeSinceLastNotification = now - lastNotificationTime;

        // 检查冷却期
        if (timeSinceLastNotification >= CONFIG.NOTIFICATION_COOLDOWN) {
            // 获取任务数量
            const sharedPoolCount = getSharedPoolTaskCount();
            const personalPoolCount = getPersonalPoolTaskCount();
            
            // 如果有任务需要处理
            if (sharedPoolCount > 0 || personalPoolCount > 0) {
                // 立即更新通知时间，避免重复通知
                lastNotificationTime = now;

                // 立即发送通知
                sendNotifications(sharedPoolCount, personalPoolCount);

                // 异步保存最后通知时间，不阻塞通知显示
                setTimeout(() => {
                    GM_setValue('lastNotificationTime', lastNotificationTime);
                }, 0);
            }
        }
    }

    // 自动刷新页面数据
    function refreshData() {
        try {
            // 点击第一个搜索按钮（共享工作池）
            const firstSearchButton = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
            if (firstSearchButton) {
                firstSearchButton.click();
            }
            
            // 延迟点击第二个搜索按钮（个人工作池）
            setTimeout(() => {
                const secondSearchButton = document.querySelector('button[onclick="refreshGrid1();"]');
                if (secondSearchButton) {
                    secondSearchButton.click();
                }
            }, 500);
        } catch (error) {
            // 忽略错误
        }
    }

    // 启动监控
    function startMonitoring() {
        if (isMonitoring) return;

        isMonitoring = true;

        // 立即检查一次，减少初始延迟
        setTimeout(() => {
            refreshData();
            setTimeout(checkAndNotify, 1500); // 减少等待时间到1.5秒
        }, 500); // 减少初始延迟到0.5秒

        // 设置定时检查
        monitorTimer = setInterval(() => {
            refreshData();
            setTimeout(checkAndNotify, 1500); // 减少等待时间到1.5秒
        }, CONFIG.CHECK_INTERVAL);

        updateToggleButton();
    }

    // 停止监控
    function stopMonitoring() {
        if (!isMonitoring) return;

        isMonitoring = false;
        if (monitorTimer) {
            clearInterval(monitorTimer);
            monitorTimer = null;
        }
        updateToggleButton();
    }

    // 切换监控状态
    function toggleMonitoring() {
        if (isMonitoring) {
            stopMonitoring();
        } else {
            startMonitoring();
        }
        
        // 更新配置按钮文本和样式
        const configButton = document.getElementById('qualityCheckConfigBtn');
        if (configButton) {
            configButton.innerHTML = isMonitoring ? '检测中' : '检测';
            if (isMonitoring) {
                configButton.style.background = '#FF5722';
                configButton.style.color = 'white';
            } else {
                // 恢复原始样式
                configButton.style.background = '';
                configButton.style.color = '';
            }
        }
        
        // 更新配置面板中的按钮文本
        const toggleButton = document.getElementById('quality-check-monitor-btn');
        if (toggleButton) {
            toggleButton.innerHTML = isMonitoring ? '停止任务监控' : '启动任务监控';
            toggleButton.style.background = isMonitoring ? '#FF5722' : '#4CAF50';
        }
    }

    // 更新按钮状态
    function updateToggleButton() {
        const button = document.getElementById('quality-check-monitor-btn');
        if (button) {
            button.textContent = isMonitoring ? '停止任务监控' : '启动任务监控';
            button.style.backgroundColor = isMonitoring ? '#F44336' : '#4CAF50';
        }
    }


    // 创建配置按钮
    function createConfigButton() {
        // 查找目标位置
        const targetDiv = document.querySelector('div.layui-input-inline.layui-show-xs-block');
        if (!targetDiv) {
            console.log('未找到目标位置，使用默认位置');
            createDefaultConfigButton();
            return;
        }

        const button = document.createElement('button');
        button.id = 'qualityCheckConfigBtn';
        button.innerHTML = '检测';
        button.className = 'layui-btn layui-btn-warm layui-btn-xs';
        button.type = 'button';
        button.style.cssText = `
            margin-left: 5px;
            cursor: pointer;
        `;
        
        // 单击启动/停止检测
        button.addEventListener('click', () => {
            toggleMonitoring();
        });
        
        // 创建一个包装容器，用于相对定位
        const wrapper = document.createElement('div');
        wrapper.style.cssText = `
            position: relative;
            display: inline-block;
            margin-left: 5px;
        `;
        wrapper.appendChild(button);
        
        // 插入到第二个按钮后面
        const secondButton = targetDiv.children[1];
        if (secondButton) {
            targetDiv.insertBefore(wrapper, secondButton.nextSibling);
        } else {
            targetDiv.appendChild(wrapper);
        }
        

    }

    // 创建默认位置的配置按钮（备用方案）
    function createDefaultConfigButton() {
        const button = document.createElement('button');
        button.id = 'qualityCheckConfigBtn';
        button.innerHTML = '检测';
        button.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            z-index: 10000;
            background: #FFB800;
            color: white;
            border: none;
            padding: 4px 8px;
            border-radius: 2px;
            cursor: pointer;
            font-size: 12px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.2);
        `;
        
        // 单击启动/停止检测
        button.addEventListener('click', () => {
            toggleMonitoring();
        });
        
        document.body.appendChild(button);
    }

    // 检测搜索按钮是否存在
    function hasSearchButtons() {
        const firstSearchButton = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
        const secondSearchButton = document.querySelector('button[onclick="refreshGrid1();"]');
        return firstSearchButton && secondSearchButton;
    }

    // 检测查询管理界面的搜索按钮是否存在（简化为：只要出现单个查询按钮即可）
    function hasQueryManagementSearchButton() {
        // 检测单个查询按钮 refreshGrid('queryForm')
        const searchBtn = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
        return !!searchBtn;
    }

    // 获取查询管理界面的任务数
    function getQueryManagementTaskCount() {
        try {
            // 精确定位页面2的表格主体容器
            const bodyContainer = document.querySelector('.layui-table-body.layui-table-main');
            if (!bodyContainer) {
                console.log('未找到页面2表格主体容器 .layui-table-body.layui-table-main');
                return 0;
            }

            // 统计 tbody 中的行数（页面2真实数据结构）
            const rows = bodyContainer.querySelectorAll('table.layui-table > tbody > tr');
            const rowCount = rows ? rows.length : 0;

            // 如有行，直接返回行数（避免"无数据"元素虽然存在但隐藏导致的误判）
            if (rowCount > 0) {
                console.log('页面2检测到行数:', rowCount);
                return rowCount;
            }

            // 没有行时，再判断是否显示"无数据"
            const noDataDiv = bodyContainer.querySelector('.layui-none');
            if (noDataDiv && noDataDiv.textContent.includes('无数据')) {
                const style = window.getComputedStyle(noDataDiv);
                const visible = style && style.display !== 'none' && style.visibility !== 'hidden' && noDataDiv.getClientRects().length > 0;
                if (visible) {
                    console.log('页面2显示无数据');
                    return 0;
                }
            }

            // 默认返回0
            return 0;
        } catch (error) {
            console.error('获取页面2任务数异常:', error);
            return 0;
        }
    }

    // 查询管理界面检查并发送通知
    function checkQueryManagementAndNotify() {
        const now = Date.now();
        const timeSinceLastNotification = now - lastQueryNotificationTime;

        // 检查冷却期（使用独立的查询管理通知时间）
        if (timeSinceLastNotification >= CONFIG.NOTIFICATION_COOLDOWN) {
            // 获取任务数量
            const taskCount = getQueryManagementTaskCount();
            
            console.log('查询管理界面检测结果:', taskCount, '个任务');
            
            // 如果有任务需要处理
            if (taskCount > 0) {
                // 立即更新通知时间，避免重复通知
                lastQueryNotificationTime = now;

                // 立即发送通知
                const nowDate = new Date();
                const timeStr = nowDate.toLocaleString('zh-CN');
                const message = `查询管理界面待处理任务${taskCount}单，请及时处理。\n时间：${timeStr}`;
                
                console.log('发送查询管理界面通知:', message);
                showLocalNotification(message, '东方嘉富任务提醒!');

                // 异步保存最后通知时间，不阻塞通知显示
                setTimeout(() => {
                    GM_setValue('lastQueryNotificationTime', lastQueryNotificationTime);
                }, 0);
            }
        } else {
            console.log('查询管理界面通知冷却期内，剩余时间:', Math.ceil((CONFIG.NOTIFICATION_COOLDOWN - timeSinceLastNotification) / 1000), '秒');
        }
    }

    // 查询管理界面自动刷新数据（带智能等待机制）
    function refreshQueryManagementData() {
        try {
            // 点击查询按钮
            const searchButton = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
            if (searchButton) {
                searchButton.click();
                // 智能等待数据加载完成，然后检测任务数并发送通知
                waitForQueryDataLoad().then(() => {
                    // 数据加载完成后，先确保检测按钮存在
                    createQueryManagementDetectButton();
                    updateQueryManagementButton();
                    // 然后执行检测和通知
                    checkQueryManagementAndNotify();
                }).catch(error => {
                    console.log('页面2数据加载等待超时，使用兜底检测');
                    // 超时后仍然尝试检测
                    createQueryManagementDetectButton();
                    updateQueryManagementButton();
                    checkQueryManagementAndNotify();
                });
            }
        } catch (error) {
            // 忽略错误
        }
    }

    // 智能等待页面2数据加载完成
    function waitForQueryDataLoad() {
        return new Promise((resolve, reject) => {
            let attempts = 0;
            const maxAttempts = 50; // 最多等待10秒 (50次 * 200ms)
            const checkInterval = 200; // 每200ms检查一次

            function checkDataLoaded() {
                attempts++;
                
                // 检查是否有加载中的状态指示器
                const loadingIndicator = document.querySelector('.layui-table-loading');
                const hasLoading = loadingIndicator && window.getComputedStyle(loadingIndicator).display !== 'none';
                
                // 检查表格容器是否存在
                const bodyContainer = document.querySelector('.layui-table-body.layui-table-main');
                
                if (!hasLoading && bodyContainer) {
                    // 没有加载状态且表格容器存在，检查是否有数据或显示"无数据"
                    const rows = bodyContainer.querySelectorAll('table.layui-table > tbody > tr');
                    const noDataDiv = bodyContainer.querySelector('.layui-none');
                    
                    // 有数据行或明确显示"无数据"时认为加载完成
                    if (rows.length > 0 || (noDataDiv && noDataDiv.textContent.includes('无数据'))) {
                        console.log(`页面2数据加载完成，用时: ${attempts * checkInterval}ms, 数据行数: ${rows.length}`);
                        resolve();
                        return;
                    }
                }
                
                // 检查是否超时
                if (attempts >= maxAttempts) {
                    console.log('页面2数据加载等待超时');
                    reject(new Error('等待超时'));
                    return;
                }
                
                // 继续等待
                setTimeout(checkDataLoaded, checkInterval);
            }
            
            // 开始检查
            setTimeout(checkDataLoaded, checkInterval);
        });
    }

    // 创建查询管理界面的检测按钮（简化：在查询按钮后面第2个按钮位置插入）
    function createQueryManagementDetectButton() {
        // 检查按钮是否已存在
        if (document.getElementById('queryManagementDetectBtn')) {
            return;
        }

        // 查找查询按钮
        const searchBtn = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
        if (!searchBtn) {
            return;
        }

        const button = document.createElement('button');
        button.id = 'queryManagementDetectBtn';
        button.innerHTML = '<i class="layui-icon"></i>检测';
        button.className = 'layui-btn layui-btn-warm layui-btn-xs';
        button.type = 'button';
        button.style.cssText = `
            margin-left: 5px;
            cursor: pointer;
        `;
        
        // 单击启动/停止检测
        button.addEventListener('click', () => {
            toggleQueryManagementMonitoring();
        });
        
        // 在查询按钮后面第2个按钮位置插入（即清空按钮之后）
        const cleanBtn = document.querySelector('button[onclick="cleanQueryForm(\'queryForm\');"]');
        if (cleanBtn && cleanBtn.parentNode) {
            if (cleanBtn.nextSibling) {
                cleanBtn.parentNode.insertBefore(button, cleanBtn.nextSibling);
            } else {
                cleanBtn.parentNode.appendChild(button);
            }
        } else if (searchBtn && searchBtn.parentNode) {
            // 兜底：直接插到查询按钮后
            if (searchBtn.nextSibling) {
                searchBtn.parentNode.insertBefore(button, searchBtn.nextSibling);
            } else {
                searchBtn.parentNode.appendChild(button);
            }
        }
    }

    // 监听查询管理界面的工具栏/查询区域变动，缺失时自动重建检测按钮（简化：以单个查询按钮出现为信号）
    function observeQueryManagementToolbar() {
        if (qmObserver) return;
        qmObserver = new MutationObserver(() => {
            const searchBtn = document.querySelector('button[onclick="refreshGrid(\'queryForm\');"]');
            const exists = document.getElementById('queryManagementDetectBtn');
            if (searchBtn && !exists) {
                createQueryManagementDetectButton();
                updateQueryManagementButton();
            }
        });
        qmObserver.observe(document.body, { childList: true, subtree: true });
    }

    // 切换查询管理界面监控状态
    function toggleQueryManagementMonitoring() {
        if (isMonitoring) {
            stopQueryManagementMonitoring();
        } else {
            startQueryManagementMonitoring();
        }
    }

    // 启动查询管理界面监控
    function startQueryManagementMonitoring() {
        if (isMonitoring) return;

        isMonitoring = true;

        // 立即检查一次（内部带智能等待）
        setTimeout(() => {
            refreshQueryManagementData();
        }, 500);

        // 设置定时检查（内部带智能等待，不再额外延时）
        monitorTimer = setInterval(() => {
            refreshQueryManagementData();
        }, CONFIG.CHECK_INTERVAL);

        updateQueryManagementButton();
    }

    // 停止查询管理界面监控
    function stopQueryManagementMonitoring() {
        if (!isMonitoring) return;

        isMonitoring = false;
        if (monitorTimer) {
            clearInterval(monitorTimer);
            monitorTimer = null;
        }
        updateQueryManagementButton();
    }

    // 更新查询管理界面按钮状态
    function updateQueryManagementButton() {
        const button = document.getElementById('queryManagementDetectBtn');
        if (button) {
            button.innerHTML = isMonitoring ? '<i class="layui-icon"></i>检测中' : '<i class="layui-icon"></i>检测';
            if (isMonitoring) {
                button.style.backgroundColor = '#FF5722';
                button.style.color = 'white';
            } else {
                // 恢复原始样式
                button.style.backgroundColor = '';
                button.style.color = '';
            }
        }
    }


    // 初始化
    function init() {
        // 检测搜索按钮是否存在，只有存在时才加载配置界面
        if (!hasSearchButtons()) {
            // 如果不是共享工作池和个人工作池页面，检查是否是查询管理界面
            if (hasQueryManagementSearchButton()) {
                // 请求通知权限
                if (Notification.permission === 'default') {
                    Notification.requestPermission();
                }

                // 恢复最后通知时间
                lastNotificationTime = GM_getValue('lastNotificationTime', 0);
                // 恢复查询管理界面独立的通知时间
                lastQueryNotificationTime = GM_getValue('lastQueryNotificationTime', 0);

                console.log('查询管理界面初始化完成，上次通知时间:', new Date(lastQueryNotificationTime).toLocaleString('zh-CN'));

                // 为查询管理界面创建检测按钮
                setTimeout(() => {
                    createQueryManagementDetectButton();
                    updateQueryManagementButton();
                }, 1000); // 延迟1秒确保页面元素加载完成

                // 开始监听工具栏变化，确保按钮持久存在
                observeQueryManagementToolbar();
            }
            return;
        }

        // 请求通知权限
        if (Notification.permission === 'default') {
            Notification.requestPermission();
        }

        // 恢复最后通知时间
        lastNotificationTime = GM_getValue('lastNotificationTime', 0);

        // 创建控制界面
        createConfigButton();
    }

    // 等待页面加载完成后初始化
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', init);
    } else {
        init();
    }

})();